package com.jevoly.utils;

import org.dom4j.DocumentException;
import org.dom4j.io.SAXReader;
import org.dom4j.Document;
import org.springframework.util.ResourceUtils;

import java.io.*;
import java.net.URISyntaxException;
import java.net.URL;
import java.util.ArrayList;
import java.util.List;

/**
 * 文件操作工具类
 */
public class FileUtil {

    /**
     * 获取项目加载根路径
     * @return
     */
    public static String getClassPath(){
        String strRes = "";
        try {
            strRes = FileUtil.class.getResource("//").toURI().getPath();
        } catch (URISyntaxException e) {
         e.printStackTrace();
        }
        return strRes;
    }

    /**
     * 获取系统静态资源目录
     * @return
     */
    public static String getStaticUrl() {
        String path = null;
        try {
            String serverpath= ResourceUtils.getURL("classpath:static").getPath().replace("%20"," ").replace('/', '\\');
            path=serverpath.substring(1);//从路径字符串中取出工程路径
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
        return path;
    }

    /**
     * 得到文件夹下的所有指定后缀文件名列表
     * @param strFolderPath 文件夹路径
     * @param strSuffix 需要遍历的的文件后缀
     * @param blIsAbsPath 是否采用绝对路径返回
     * @return
     */
    public static List<String> getFileName(String strFolderPath, String strSuffix, boolean blIsAbsPath) {
        List<String> lsFileName = new ArrayList<String>();

        //用于查找文件
        File getDocument;
        if (strFolderPath == null || strFolderPath.equals("")) {
            return null;
        } else {
            if (strFolderPath.substring(strFolderPath.length()-1).equals("/")) {
                strFolderPath = strFolderPath.substring(0, strFolderPath.length()-1);
            }
            getDocument = new File(strFolderPath);
        }
        //存储文件容器
        String getFileName[];
        getFileName = getDocument.list();
        if (getFileName==null || getFileName.length<1) {
            return null;
        }

        //遍历整合
        for (int i = 0; i < getFileName.length; i++) {
            //文件名合法性检查
            String strFileNameTmp = getFileName[i];
            if (strFileNameTmp.length() <= strSuffix.length()) {
                continue;
            }
            if (!strFileNameTmp.substring(strFileNameTmp.length() - strSuffix.length()).equals(strSuffix)) {
                //文件后缀不符合的情况
                continue;
            }
            //文件路径加载
            String strFileName = "";
            if (blIsAbsPath) {
                strFileName = strFolderPath + File.separator + getFileName[i];
            }else{
                strFileName = getFileName[i];
            }
            lsFileName.add(strFileName);
        }
        return lsFileName;
    }

    public static List<String> getFileName(String strFolderPath, List<String> suffixList, boolean blIsAbsPath) {
        List<String> lsFileName = new ArrayList<String>();

        //用于查找文件
        File getDocument;
        if (strFolderPath == null || strFolderPath.equals("")) {
            return null;
        } else {
            if (strFolderPath.substring(strFolderPath.length()-1).equals("/")) {
                strFolderPath = strFolderPath.substring(0, strFolderPath.length()-1);
            }
            getDocument = new File(strFolderPath);
        }
        //存储文件容器
        String getFileName[];
        getFileName = getDocument.list();
        if (getFileName==null || getFileName.length<1) {
            return null;
        }

        //遍历整合
        for (int i = 0; i < getFileName.length; i++) {
            //文件名合法性检查
            String strFileNameTmp = getFileName[i];
            if (strFileNameTmp.length() <= suffixList.get(0).length()) {
                continue;
            }
            // 获取文件后缀名
            String suffixTmp = getFileSuffix(strFileNameTmp);
            if (!suffixList.contains(suffixTmp)) {
                continue;
            }
            //文件路径加载
            String strFileName = "";
            if (blIsAbsPath) {
                strFileName = strFolderPath + File.separator + getFileName[i];
            }else{
                strFileName = getFileName[i];
            }
            lsFileName.add(strFileName);
        }
        return lsFileName;
    }

    public static List<String> getFileName(String strFolderPath, String strSuffix){
        return getFileName(strFolderPath, strSuffix, true);
    }

    /**
     * 获取文件后缀名
     * @param fileName
     * @return
     */
    public static String getFileSuffix(String fileName) {
        if (!fileName.contains(".")) {
            return "";
        }
        String[] jevoly = fileName.split("\\.");
        return jevoly[jevoly.length - 1];
    }

    public static String transFile2Str(String strFilePath){

        //创建SAXReader对象
        SAXReader reader = new SAXReader();
        //读取文件 转换成Document
        Document document = null;
        try {
            document = reader.read(new File(getClassPath() + strFilePath));
        } catch (DocumentException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        //document转换为String字符串
        String documentStr = document.asXML();
        return documentStr;

    }

    /**
     * 列表转换为字符串
     * 最后一个元素后不加分隔符
     * @param list
     * @param separator
     * @return
     */
    public static String listToString(List list, char separator) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < list.size(); i++) {
            if (i == list.size() - 1) {
                sb.append(list.get(i));
            } else {
                sb.append(list.get(i));
                sb.append(separator);
            }
        }
        return sb.toString();
    }

    /**
     * 目录拷贝
     * @param srcPath
     * @param destPath
     */
    public static void dirCopy(String srcPath, String destPath) {
        File src = new File(srcPath);
        if (!new File(destPath).exists()) {
            new File(destPath).mkdirs();
        }
        for (File s : src.listFiles()) {
            if (s.isFile()) {
                fileCopy(s.getPath(), destPath + File.separator + s.getName());
            } else {
                dirCopy(s.getPath(), destPath + File.separator + s.getName());
            }
        }
    }

    /**
     * 文件拷贝
     * @param srcPath
     * @param destPath
     */
    public static void fileCopy(String srcPath, String destPath) {
        File src = new File(srcPath);
        File dest = new File(destPath);
        //使用jdk1.7 try-with-resource 释放资源，并添加了缓存流
        try(InputStream is = new BufferedInputStream(new FileInputStream(src));
            OutputStream out =new BufferedOutputStream(new FileOutputStream(dest))) {
            byte[] flush = new byte[1024];
            int len = -1;
            while ((len = is.read(flush)) != -1) {
                out.write(flush, 0, len);
            }
            out.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 删除目录下所有文件
     * @param path
     */
    public static boolean deleteDir(String path){
        File file = new File(path);
        if(!file.exists()){ // 判断是否待删除目录是否存在
            System.err.println("The dir are not exists!");
            return false;
        }
        String[] content = file.list(); // 取得当前目录下所有文件和文件夹
        for(String name : content){
            File temp = new File(path, name);
            if(temp.isDirectory()){ // 判断是否是目录
                deleteDir(temp.getAbsolutePath()); // 递归调用，删除目录里的内容
                temp.delete(); // 删除空目录
            }else{
                if(!temp.delete()){ // 直接删除文件
                    System.err.println("Failed to delete " + name);
                }
            }
        }
        return true;
    }

    /**
     * 删除文件
     * @param file
     */
    public static void deleteFile(File file) {
        if(file.exists()) {//判断路径是否存在
            if(file.isFile()){//boolean isFile():测试此抽象路径名表示的文件是否是一个标准文件。
                file.delete();
            }else{//不是文件，对于文件夹的操作
                //保存 路径D:/1/新建文件夹2  下的所有的文件和文件夹到listFiles数组中
                File[] listFiles = file.listFiles();//listFiles方法：返回file路径下所有文件和文件夹的绝对路径
                for (File file2 : listFiles) {
					/*
					 * 递归作用：由外到内先一层一层删除里面的文件 再从最内层 反过来删除文件夹
					 *    注意：此时的文件夹在上一步的操作之后，里面的文件内容已全部删除
					 *         所以每一层的文件夹都是空的  ==》最后就可以直接删除了
					 */
                    deleteFile(file2);
                }
            }
            file.delete();
        }else {
            System.out.println("该file路径不存在！！");
        }
    }




    public static void main(String[] args) {
//        System.out.println(System.getProperty("user.dir"));
//        System.out.println(getStaticUrl());

//        String fileName = "你好.texgt";
//        String fileName2 = "abc.jpg";
//        String fileName1 = "hello.png";
//        List<String> suffixList = new ArrayList<>();
//        suffixList.add("jpg");
//        suffixList.add("png");
//        List<String> fileList = getFileName(getStaticUrl() + "\\images\\album", suffixList, true);
//        for (String str : fileList) {
//            System.out.println(str);
//        }
    }
}
 